package com.css.zfzx.fwsjcj.modules.report.service.Impl;

import com.css.bpm.platform.api.local.PlatformAPI;
import com.css.bpm.platform.api.local.org.UserAPI;
import com.css.bpm.platform.org.user.repository.entity.UserEntity;
import com.css.bpm.platform.utils.PlatformSessionUtils;
import com.css.zfzx.fwsjcj.commen.util.Constant;
import com.css.zfzx.fwsjcj.commen.util.DateUtils;
import com.css.zfzx.fwsjcj.commen.util.ImageUtil;
import com.css.zfzx.fwsjcj.commen.util.WordUtil;
import com.css.zfzx.fwsjcj.config.image.ConfigBeanValue;
import com.css.zfzx.fwsjcj.modules.analysis.vo.AnalysisQueryVo;
import com.css.zfzx.fwsjcj.modules.group.entity.FwGroupEntity;
import com.css.zfzx.fwsjcj.modules.group.entity.FwGroupUserEntity;
import com.css.zfzx.fwsjcj.modules.group.service.FwGroupService;
import com.css.zfzx.fwsjcj.modules.group.service.FwGroupUserService;
import com.css.zfzx.fwsjcj.modules.report.service.ExportReportService;
import com.css.zfzx.fwsjcj.modules.taskmanage.task.entity.FwTaskEntity;
import com.css.zfzx.fwsjcj.modules.taskmanage.task.service.TaskService;
import com.css.zfzx.fwsjcj.modules.taskmanage.taskfrom.entity.*;
import com.css.zfzx.fwsjcj.modules.taskmanage.taskfrom.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

@Service
public class ExportReportServiceImpl implements ExportReportService {
    @Autowired
    private ConfigBeanValue configBeanValue;
    @Autowired
    TaskFromService taskFromService;
    @Autowired
    CityTaskFormService cityTaskFormService;
    @Autowired
    NoCityTaskFromService noCityTaskFromService;
    @Autowired
    VillageHouseFormService villageHouseFormService;
    @Autowired
    VillagePubHouseFormService villagePubHouseFormService;
    @Autowired
    TaskService taskService;
    @Autowired
    FwGroupUserService fwGroupUserService;
    @Autowired
    FwGroupService fwGroupService;


    @Override
    public Integer exportReport(String province, String city,String area,String taskName,String timeStamp,HttpServletRequest request, HttpServletResponse response) {
        Calendar instance = Calendar.getInstance();
        int result = 0;
        //获取当前时间的年、月、日
        int year = instance.get(Calendar.YEAR);
        //月份是从0开始的，而现实生活是从一月份开始的，所以要+1
        int month = instance.get(Calendar.MONTH) + 1;
        int day = instance.get(Calendar.DATE);
        //String province0="北京市";
        //根据地址查询表单符合的表单
        List<FwFormEntity> fromList = new ArrayList<>();
        if (StringUtils.isEmpty(taskName)){
            if (StringUtils.isEmpty(province)){
                fromList = taskFromService.findAllCountry();
            }else {
                fromList = taskFromService.findByAddress(province, city,area);
            }
        }else {
            String[] strArray = taskName.split(",");
            List<String> taskNameList = Arrays.asList(strArray);
            for (String name : taskNameList) {
                FwTaskEntity fwTaskEntity = taskService.findbyName(name);
                fromList.addAll(taskFromService.findByTaskId(fwTaskEntity.getTaskId()));
            }
        }
        //如果list不为空和长度>0
        if (!StringUtils.isEmpty(fromList) && fromList.size() > 0) {
            //纬度list
            List<Float> latitude = new ArrayList<>();
            //区的list
            List<String> listArea = new ArrayList<>();
            //经度list
            List<Float> longitude = new ArrayList<>();
            //时间list
            List<Date> listDate=new ArrayList<>();
            //任务list
            List<String> listTaskId=new ArrayList<>();
            //组长Id
            List<String> listLeaderId=new ArrayList<>();
            //小组ID
            List<String> listGroupId=new ArrayList<>();
            //小组关联表
            List<FwGroupUserEntity> listGroupUser=new ArrayList<>();
            //面积总数
            int areaCount=0;
            for(FwFormEntity fwFormEntity:fromList ){
                //将String类型的纬度转换成float
                float latitudeFloat = Float.parseFloat(fwFormEntity.getBulidingLatitude());
                //获取区域面积
                String belongtoArea = fwFormEntity.getBelongtoArea();
                //将String类型的经度转换成float
                float longitudeFloat = Float.parseFloat(fwFormEntity.getBulidingLongitude());
                //获取子表的id
                String formId = fwFormEntity.getFormId();
                //获取创建时间
                Date createTime=fwFormEntity.getCreateTime();
                //获取建筑类型
                String bulidingType = fwFormEntity.getBulidingType();
                //获取任务Id
                String taskId = fwFormEntity.getTaskId();
                //如果为城镇住宅
                FwCtiyHouseEntity cityForm=null;
                if(Constant.BULIDING_CITY.equals(bulidingType)){
                    cityForm = cityTaskFormService.findCityById(formId);
                }
                //如果为城镇非住宅
                FwNoctiyHouseEntity fwNocityHouseEntity = null;
                if(Constant.BULIDING_NOCITY.equals(bulidingType)){
                    fwNocityHouseEntity=noCityTaskFromService.findNoCityById(formId);
                }
                //如果为农村建筑
                FwVillageHouseEntity fwVillageHouseEntity=null;
                if (Constant.BULIDING_VIllAGE.equals(bulidingType)){
                    fwVillageHouseEntity=villageHouseFormService.findVillageHouseById(formId);
                }
                //如果为农村非公共建筑
                FwVillagePubhouseEntity fwVillagePubhouseEntity=null;
                if(Constant.BULIDING_VIllAGEPUB.equals(bulidingType)){
                  fwVillagePubhouseEntity=villagePubHouseFormService.findVillagePubHouseById(formId);
                }
                //城镇住宅面积
                int cityArea=0;
                if(!StringUtils.isEmpty(cityForm)){
                    cityArea =cityForm.getBuildingArea().intValue();
                }
                //城镇非住宅面积
                int nocity=0;
                if(!StringUtils.isEmpty(fwNocityHouseEntity)){
                  nocity=fwNocityHouseEntity.getBuildingArea().intValue();
                }
                //农村建筑面积
                int villageHouse=0;
                if(!StringUtils.isEmpty(fwVillageHouseEntity)){
                   villageHouse=fwVillageHouseEntity.getBuildingArea().intValue();
                }
                //农村公共建筑面积
                int villagePubHouse=0;
                if(!StringUtils.isEmpty(fwVillagePubhouseEntity)){
                   villagePubHouse=fwVillagePubhouseEntity.getBuildingArea().intValue();
                }
                //建筑总面积
                areaCount+=cityArea+nocity+villageHouse+villagePubHouse;
                listArea.add(belongtoArea);
                latitude.add(latitudeFloat);
                longitude.add(longitudeFloat);
                listDate.add(createTime);
                listTaskId.add(taskId);
            }
            //任务包含的区去重
            String areaArray = "";
            List<String> areaList=new ArrayList<>(new TreeSet<>(listArea));
            for (String areaNmae: areaList) {
                areaArray = areaArray + areaNmae + "、";
            }
            int lastIndex = areaArray.lastIndexOf("、");
                if (lastIndex != -1) { // 如果字符串中存在逗号
                areaArray = areaArray.substring(0, lastIndex) + areaArray.substring(lastIndex + 1);
            }
            //查询条件
            AnalysisQueryVo analysisQueryVo = new AnalysisQueryVo();
            analysisQueryVo.setBelongtoProvince(province);
            analysisQueryVo.setBelongtoCity(city);
            analysisQueryVo.setBelongtoArea(area);
            analysisQueryVo.setTaskName(taskName);
            analysisQueryVo.setSpType(Constant.SP_YES);
            //城镇住宅总栋数
            long countCity = cityTaskFormService.count(analysisQueryVo);
            //城镇住宅总面积
            int areaCity = cityTaskFormService.areaCount(analysisQueryVo);
            //城镇非住宅总栋数
            long countNoCity = noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅总面积
            int areaNoCity = noCityTaskFromService.areaCount(analysisQueryVo);
            //农村建筑总栋数
            long countVillage = villageHouseFormService.count(analysisQueryVo);
            //农村建筑总面积
            int areaVillage = villageHouseFormService.areaCount(analysisQueryVo);
            //农村公共建筑总数
            long countVillagePub = villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑总面积
            int areaVillagePub=villagePubHouseFormService.areaCount(analysisQueryVo);
            //本次总栋数
            long countNum=countCity+countNoCity+countVillage+countVillagePub;
            //本次总面积
            int areaNum=areaCity+areaNoCity+areaVillage+areaVillagePub;
            //本报告下的砖混
            analysisQueryVo.setStructureType("砖混");
            //本报告下的城镇住宅砖混建筑数量
            long cityBrickMixNum=cityTaskFormService.count(analysisQueryVo);
            //本报告下的城镇住宅砖混建筑数量占比
            StringBuilder cityBrickMixNumProportion=null;
            //城镇住宅建筑总数量必须大于零
            if(countCity>0L){
              double cityBrickMix =(cityBrickMixNum/(double)countCity)*100;
                String format = String.format("%.2f", cityBrickMix);
                cityBrickMixNumProportion=new StringBuilder();
                cityBrickMixNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅砖混建筑数量
            long nocityBrickMixNum=noCityTaskFromService.count(analysisQueryVo);
            //本报告下城镇非住宅砖混建筑数量占比
            StringBuilder nocityBirckMixProportion=null;
            //城镇非住宅建筑数量必须大于零
            if(countNoCity>0){
               double nocityBrickMix=(nocityBrickMixNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityBrickMix);
                nocityBirckMixProportion=new StringBuilder();
                nocityBirckMixProportion.append(format+"%");
            }
           //本报告下城镇住宅砖混建筑面积
            int cityBrickMixArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅砖混建筑面积占比
            StringBuilder cityBrickMixAreaProportion=null;
            //城镇住宅面积总数不能为零
            if(areaCity>0){
                double cityBrickMixProtion =(cityBrickMixArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityBrickMixProtion);
                cityBrickMixAreaProportion=new StringBuilder();
                cityBrickMixAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅砖混建筑面积
            int nocityBrickMixArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅砖混建筑面积占比
            StringBuilder nocityBrickMixAreaProportion=null;
            //城镇非住宅面积总数必须大于等于0
            if(areaNoCity>0){
                double cityBrickMixProtion =(nocityBrickMixArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", cityBrickMixProtion);
                nocityBrickMixAreaProportion=new StringBuilder();
                nocityBrickMixAreaProportion.append(format+"%");
            }
            //本报告下的底层混凝土柱-上部砖混
            analysisQueryVo.setStructureType("底层混凝土柱-上部砖混");
            //本报告下的城镇住宅底层混凝土柱-上部砖混建筑数量
            long cityTopBrickNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅底层混凝土柱-上部砖混建筑数量占比
            StringBuilder cityTopBrickNumProportion=null;
            //城镇住宅总数必须大于0
            if(countCity>0){
               double cityTopBrick=(cityTopBrickNum/(double)countCity)*100;
               String format = String.format("%.2f", cityTopBrick);
               cityTopBrickNumProportion=new StringBuilder();
               cityTopBrickNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅底层混凝土柱-上部砖混建筑数量
            long nocityTopBrickNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅底层混凝土柱-上部砖混建筑数量占比
            StringBuilder nocityTopBrickNumProportion=null;
            //城镇非住宅建筑总数必须大于0
            if(countNoCity>0){
             double  nocityTopBrick= (nocityTopBrickNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityTopBrick);
                nocityTopBrickNumProportion=new StringBuilder();
                nocityTopBrickNumProportion.append(format+"%");
            }
            //本报告下城镇住宅底层混凝土柱-上部砖混建筑面积
            int cityTopBrickArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅底层混凝土柱-上部砖混建筑面积占比
            StringBuilder cityTopBrickAreaProportion=null;
            //城镇住宅面积总数必须大于0
            if(areaCity>0){
               double cityTopBrick=(cityTopBrickArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityTopBrick);
                cityTopBrickAreaProportion=new StringBuilder();
                cityTopBrickAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅底层混凝土柱-上部砖混建筑面积
            int nocityTopBrickArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅底层混凝土柱-上部砖混占比
            StringBuilder nocityTopBrickAreaProportion=null;
            //城镇非住宅面积总数必须大于0
            if(areaNoCity>0){
               double nocityTopBrick =(nocityTopBrickArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", nocityTopBrick);
                nocityTopBrickAreaProportion=new StringBuilder();
                nocityTopBrickAreaProportion.append(format+"%");
            }
            //本报告下的钢筋混凝土
            analysisQueryVo.setStructureType("钢筋混凝土");
            //本报告下的城镇住宅钢筋混凝土建筑数量
            long cityReinforcedConcreteNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅钢筋混凝土建筑数量占比
            StringBuilder cityReinforcedConcreteNumProportion=null;
            //城镇住宅总数量必须大于0
            if(countCity>0){
                double  cityReinforcedConcrete=(cityReinforcedConcreteNum/(double)countCity)*100;
                String format = String.format("%.2f", cityReinforcedConcrete);
                cityReinforcedConcreteNumProportion=new StringBuilder();
                cityReinforcedConcreteNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅钢筋混凝土建筑数量
            long nocityReinforcedConcreteNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅钢筋混凝土建筑数量占比
            StringBuilder nocityReinforcedConcreteNumProportio=null;
            //城镇非住宅建筑总数量必须大于0
            if(countNoCity>0){
               double nocityReinforcedConcrete=(nocityReinforcedConcreteNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityReinforcedConcrete);
                nocityReinforcedConcreteNumProportio=new StringBuilder();
                nocityReinforcedConcreteNumProportio.append(format+"%");
            }
            //本报告下城镇住宅钢筋混凝土建筑面积
            int cityReinforcedConcreteArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅钢筋混凝土建筑面积占比
            StringBuilder cityReinforcedConcreteAreaProportion=null;
            //城镇住宅面积总数必须大于0
            if(areaCity>0){
                double cityReinforcedConcrete=(cityReinforcedConcreteArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityReinforcedConcrete);
                cityReinforcedConcreteAreaProportion=new StringBuilder();
                cityReinforcedConcreteAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅钢筋混凝土建筑面积
            int nocityReinforcedConcreteArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅钢筋混凝土建筑面积占比
            StringBuilder nocityReinforcedConcreteAreaProportion=null;
            //城镇非住宅总数必须大于0
            if(areaNoCity>0){
                double nocityReinforcedConcrete=(nocityReinforcedConcreteArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", nocityReinforcedConcrete);
                nocityReinforcedConcreteAreaProportion=new StringBuilder();
                nocityReinforcedConcreteAreaProportion.append(format+"%");
            }
            //本报告下的砖木
            analysisQueryVo.setStructureType("砖木");
            //本报告下的城镇住宅砖木建筑数量
            long cityBrickWoodNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅砖木建筑数量占比
            StringBuilder cityBrickWoodNumProportion=null;
            //城镇住宅总数量必须大于0
            if(countCity>0){
                double  cityBrickWood=(cityBrickWoodNum/(double)countCity)*100;
                String format = String.format("%.2f", cityBrickWood);
                cityBrickWoodNumProportion=new StringBuilder();
                cityBrickWoodNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅砖木建筑数量
            long nocityBrickWoodNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅砖木建筑数量占比
            StringBuilder nocityBrickWoodNumProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(countNoCity>0){
                double nocityBrickWood=(nocityBrickWoodNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityBrickWood);
                nocityBrickWoodNumProportion=new StringBuilder();
                nocityBrickWoodNumProportion.append(format+"%");
            }
            //本报告下城镇住宅砖木建筑面积
            int cityBrickWoodArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅砖木建筑面积占比
            StringBuilder cityBrickWoodAreaProportion=null;
            //城镇住宅面积总数必须大于0
            if(areaCity>0){
                double cityBrickWood=(cityBrickWoodArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityBrickWood);
                cityBrickWoodAreaProportion=new StringBuilder();
                cityBrickWoodAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅砖木建筑面积
            int nocityBrickWoodArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅砖木建筑面积占比
            StringBuilder nocityBrickWoodAreaProportion=null;
            //城镇非住宅总数必须大于0
            if(areaNoCity>0){
                double nocityBrickWood=(nocityBrickWoodArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", nocityBrickWood);
                nocityBrickWoodAreaProportion=new StringBuilder();
                nocityBrickWoodAreaProportion.append(format+"%");
            }
            //本报告下钢结构
            analysisQueryVo.setStructureType("钢结构");
            //本报告下的城镇住宅钢结构建筑数量
            long citySteelStructureNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅钢结构建筑数量占比
            StringBuilder citySteelStructureNumProportion=null;
            //城镇住宅总数量必须大于0
            if(countCity>0){
                double citySteelStructure=(citySteelStructureNum/(double)countCity)*100;
                String format = String.format("%.2f", citySteelStructure);
                citySteelStructureNumProportion=new StringBuilder();
                citySteelStructureNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅钢结构建筑数量
            long nocitySteelStructureNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅钢结构建筑数量占比
            StringBuilder nocitySteelStructureNumProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(countNoCity>0){
                double nocitySteelStructure=(nocitySteelStructureNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocitySteelStructure);
                nocitySteelStructureNumProportion=new StringBuilder();
                nocitySteelStructureNumProportion.append(format+"%");
            }
            //本报告下城镇住宅钢结构建筑面积
            int citySteelStructureArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅钢结构建筑面积占比
            StringBuilder citySteelStructureAreaProportion=null;
            //城镇住宅建筑总数量必须大于0
            if(areaCity>0){
                double citySteelStructure=(citySteelStructureArea/(double)areaCity)*100;
                String format = String.format("%.2f", citySteelStructure);
                citySteelStructureAreaProportion=new StringBuilder();
                citySteelStructureAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅钢结构建筑面积
            int nocitySteelStructureArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅钢结构建筑面积占比
            StringBuilder nocitySteelStructureAreaProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(areaNoCity>0){
                double nocitySteelStructure=(nocitySteelStructureArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", nocitySteelStructure);
                nocitySteelStructureAreaProportion=new StringBuilder();
                nocitySteelStructureAreaProportion.append(format+"%");
            }
            //本报告下木结构
            analysisQueryVo.setStructureType("木结构");
            //本报告下的城镇住宅木结构建筑数量
            long cityWoodStructureNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅钢结构建筑数量占比
            StringBuilder cityWoodStructureNumProportion=null;
            //城镇住宅总数量必须大于0
            if(countCity>0){
                double cityWoodStructure=(cityWoodStructureNum/(double)countCity)*100;
                String format = String.format("%.2f", cityWoodStructure);
                cityWoodStructureNumProportion=new StringBuilder();
                cityWoodStructureNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅木结构建筑数量
            long nocityWoodStructureNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅钢结构建筑数量占比
            StringBuilder nocityWoodStructureNumProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(countNoCity>0){
                double nocityWoodStructure=(nocityWoodStructureNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityWoodStructure);
                nocityWoodStructureNumProportion=new StringBuilder();
                nocityWoodStructureNumProportion.append(format+"%");
            }
            //本报告下城镇住宅木结构建筑面积
            int cityWoodStructureArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅宅木结构建筑面积占比
            StringBuilder cityWoodStructureAreaProportion=null;
            //城镇住宅建筑总数量必须大于0
            if(areaCity>0){
                double cityWoodStructure=(cityWoodStructureArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityWoodStructure);
                cityWoodStructureAreaProportion=new StringBuilder();
                cityWoodStructureAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅木结构建筑面积
            int nocityWoodStructureArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅木结构建筑面积占比
            StringBuilder nocityWoodStructureAreaProportion=null;
            //城镇非住宅木结构建筑面积总数必须大于0
            if(areaNoCity>0){
                double nocityWoodStructure=(nocityWoodStructureArea/(double)areaCity)*100;
                String format = String.format("%.2f", nocityWoodStructure);
                nocityWoodStructureAreaProportion=new StringBuilder();
                nocityWoodStructureAreaProportion.append(format+"%");
            }
            //本报告下其它
            analysisQueryVo.setStructureType("其它");
            //本报告下的城镇住宅其它建筑数量
            long cityOtherNum=cityTaskFormService.count(analysisQueryVo);
            //城镇住宅钢其它建筑数量占比
            StringBuilder cityOtherNumProportion=null;
            //城镇住宅总数量必须大于0
            if(countCity>0){
                double cityOther=(cityOtherNum/(double)countCity)*100;
                String format = String.format("%.2f", cityOther);
                cityOtherNumProportion=new StringBuilder();
                cityOtherNumProportion.append(format+"%");
            }
            //本报告下城镇非住宅其它建筑数量
            long nocityOtherNum=noCityTaskFromService.count(analysisQueryVo);
            //城镇非住宅其它建筑数量占比
            StringBuilder nocityOtherNumProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(countNoCity>0){
                double nocityOther=(nocityOtherNum/(double)countNoCity)*100;
                String format = String.format("%.2f", nocityOther);
                nocityOtherNumProportion=new StringBuilder();
                nocityOtherNumProportion.append(format+"%");
            }
            //本报告下城镇住宅其它建筑面积
            int cityOtherArea=cityTaskFormService.areaCount(analysisQueryVo);
            //城镇住宅宅木结构建筑面积占比
            StringBuilder cityOtherAreaProportion=null;
            //城镇住宅建筑总数量必须大于0
            if(areaCity>0){
                double cityOther=(cityOtherArea/(double)areaCity)*100;
                String format = String.format("%.2f", cityOther);
                cityOtherAreaProportion=new StringBuilder();
                cityOtherAreaProportion.append(format+"%");
            }
            //本报告下城镇非住宅其它建筑面积
            int nocityOtherArea=noCityTaskFromService.areaCount(analysisQueryVo);
            //城镇非住宅其它建筑面积占比
            StringBuilder nocityOtherAreaProportion=null;
            //城镇非住宅建筑总数量必须大于0
            if(areaNoCity>0){
                double cityOther=(nocityOtherArea/(double)areaNoCity)*100;
                String format = String.format("%.2f", cityOther);
                nocityOtherAreaProportion=new StringBuilder();
                nocityOtherAreaProportion.append(format+"%");
            }
            //本报告下砖（砌块）混
            analysisQueryVo.setStructureType("砖(砌块)混");
            //农村住宅砖（砌块）混总数
            long villageBrickNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅砖（砌块）混总数占比
            StringBuilder villageBrickNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
               double villageBrick=(villageBrickNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageBrickNumProportion=new StringBuilder();
                villageBrickNumProportion.append(format+"%");
            }
            //农村公共建筑砖（砌块）混总数
            long villagePubBrickNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑砖（砌块）混总数占比
            StringBuilder villagePubBrickNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubBrickNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubBrickNumProportion=new StringBuilder();
                villagePubBrickNumProportion.append(format+"%");
            }
            //农村住宅砖（砌块）混总面积
            long villageBrickArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅砖（砌块）混总面积占比
            StringBuilder villageBrickAreaProportion=null;
            //农村住宅总面积必须大于0
            if(areaVillage>0){
                double villageBrick=(villageBrickArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageBrickAreaProportion=new StringBuilder();
                villageBrickAreaProportion.append(format+"%");
            }
            //农村公共建筑砖（砌块）混总面积
            long villagePubBrickArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑砖（砌块）混总面积占比
            StringBuilder villagePubBrickAreaProportion=null;
            //农村公共建筑总面积必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubBrickArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubBrickAreaProportion=new StringBuilder();
                villagePubBrickAreaProportion.append(format+"%");
            }
            //本报告下低层框架
            analysisQueryVo.setStructureType("低层框架");
            //农村住宅低层框架总数
            long villageLowerFrameNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅低层框架总数占比
            StringBuilder villageLowerFrameNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageLowerFrameNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageLowerFrameNumProportion=new StringBuilder();
                villageLowerFrameNumProportion.append(format+"%");
            }
            //农村公共建筑低层框架总数
            long villagePubLowerFrameNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑低层框架总数占比
            StringBuilder villagePubLowerFrameNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubLowerFrameNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubLowerFrameNumProportion=new StringBuilder();
                villagePubLowerFrameNumProportion.append(format+"%");
            }
            //农村住宅低层框架总面积
            long villageLowerFrameArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅低层框架总面积占比
            StringBuilder villageLowerFrameAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageLowerFrameArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageLowerFrameAreaProportion=new StringBuilder();
                villageLowerFrameAreaProportion.append(format+"%");
            }
            //农村公共建筑低层框架总面积
            long villagePubLowerFrameArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑低层框架总面积占比
            StringBuilder villagePubLowerFrameAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubLowerFrameArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubLowerFrameAreaProportion=new StringBuilder();
                villagePubLowerFrameAreaProportion.append(format+"%");
            }
            //本报告轻钢（钢）装配式
            analysisQueryVo.setStructureType("轻钢(钢)装配式");
            //农村住宅轻钢（钢）装配式总数
            long villageSteelAssemblyNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅轻钢（钢）装配式总数占比
            StringBuilder villageSteelAssemblyNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageSteelAssemblyNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageSteelAssemblyNumProportion=new StringBuilder();
                villageSteelAssemblyNumProportion.append(format+"%");
            }
            //农村公共建筑轻钢（钢）装配式总数
            long villagePubSteelAssemblyNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑轻钢（钢）装配式总数占比
            StringBuilder villagePubSteelAssemblyNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubSteelAssemblyNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubSteelAssemblyNumProportion=new StringBuilder();
                villagePubSteelAssemblyNumProportion.append(format+"%");
            }
            //农村住宅轻钢（钢）装配式总面积
            long villageSteelAssemblyArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅轻钢（钢）装配式总面积占比
            StringBuilder villageSteelAssemblyAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageSteelAssemblyArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageSteelAssemblyAreaProportion=new StringBuilder();
                villageSteelAssemblyAreaProportion.append(format+"%");
            }
            //农村公共建筑轻钢（钢）装配式总面积
            long villagePubSteelAssemblyArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑轻钢（钢）装配式总面积占比
            StringBuilder villagePubSteelAssemblyAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubSteelAssemblyArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubSteelAssemblyAreaProportion=new StringBuilder();
                villagePubSteelAssemblyAreaProportion.append(format+"%");
            }
            //本报告混凝土装配式
            analysisQueryVo.setStructureType("混凝土装配式");
            //农村住宅混凝土装配式总数
            long villageConcreteAssemblyNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅混凝土装配式总数占比
            StringBuilder villageConcreteAssemblyNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageConcreteAssemblyNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageConcreteAssemblyNumProportion=new StringBuilder();
                villageConcreteAssemblyNumProportion.append(format+"%");
            }
            //农村公共建筑混凝土装配式总数
            long villagePubConcreteAssemblyNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑混凝土装配式总数占比
            StringBuilder villagePubConcreteAssemblyNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubConcreteAssemblyNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubConcreteAssemblyNumProportion=new StringBuilder();
                villagePubConcreteAssemblyNumProportion.append(format+"%");
            }
            //农村住宅混凝土装配式总面积
            long villageConcreteAssemblyArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅混凝土装配式总面积占比
            StringBuilder villageConcreteAssemblyAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageConcreteAssemblyArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageConcreteAssemblyAreaProportion=new StringBuilder();
                villageConcreteAssemblyAreaProportion.append(format+"%");
            }
            //农村公共建筑混凝土装配式总面积
            long villagePubConcreteAssemblyArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑混凝土装配式总面积占比
            StringBuilder villagePubConcreteAssemblyAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubConcreteAssemblyArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubConcreteAssemblyAreaProportion=new StringBuilder();
                villagePubConcreteAssemblyAreaProportion.append(format+"%");
            }
            //本报告砖木
            analysisQueryVo.setStructureType("砖木");
            //农村住宅砖木总数
            long villageBrickWoodNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅砖木总数占比
            StringBuilder villageBrickWoodNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageBrickWoodNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageBrickWoodNumProportion=new StringBuilder();
                villageBrickWoodNumProportion.append(format+"%");
            }
            //农村公共建筑砖木总数
            long villagePubBrickWoodNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑砖木总数占比
            StringBuilder villagePubBrickWoodNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubBrickWoodNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubBrickWoodNumProportion=new StringBuilder();
                villagePubBrickWoodNumProportion.append(format+"%");
            }
            //农村住宅砖木总面积
            long villageBrickWoodArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅砖木总面积占比
            StringBuilder villageBrickWoodAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageBrickWoodArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageBrickWoodAreaProportion=new StringBuilder();
                villageBrickWoodAreaProportion.append(format+"%");
            }
            //农村公共建筑砖木总面积
            long villagePubBrickWoodArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑砖木总面积占比
            StringBuilder villagePubBrickWoodAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubBrickWoodArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubBrickWoodAreaProportion=new StringBuilder();
                villagePubBrickWoodAreaProportion.append(format+"%");
            }
            //本报告土木
            analysisQueryVo.setStructureType("土木");
            //农村住宅土木总数
            long villageCivilWoodNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅土木总数占比
            StringBuilder villageCivilWoodNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageCivilWoodNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageCivilWoodNumProportion=new StringBuilder();
                villageCivilWoodNumProportion.append(format+"%");
            }
            //农村公共建筑土木总数
            long villagePubCivilWoodNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑土木总数占比
            StringBuilder villagePubCivilWoodNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubCivilWoodNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubCivilWoodNumProportion=new StringBuilder();
                villagePubCivilWoodNumProportion.append(format+"%");
            }
            //农村住宅土木总面积
            long villageCivilWoodArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅土木总面积占比
            StringBuilder villageCivilWoodAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageCivilWoodArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageCivilWoodAreaProportion=new StringBuilder();
                villageCivilWoodAreaProportion.append(format+"%");
            }
            //农村公共建筑土木总面积
            long villagePubCivilWoodArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑土木总面积占比
            StringBuilder villagePubCivilWoodAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubCivilWoodArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubCivilWoodAreaProportion=new StringBuilder();
                villagePubCivilWoodAreaProportion.append(format+"%");
            }
            //本报告石木
            analysisQueryVo.setStructureType("石木");
            //农村住宅石木总数
            long villageStoneWoodNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅石木总数占比
            StringBuilder villageStoneWoodNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageStoneWoodNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageStoneWoodNumProportion=new StringBuilder();
                villageStoneWoodNumProportion.append(format+"%");
            }
            //农村公共建筑石木总数
            long villagePubStoneWoodNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑石木总数占比
            StringBuilder villagePubStoneWoodNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubStoneWoodNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubStoneWoodNumProportion=new StringBuilder();
                villagePubStoneWoodNumProportion.append(format+"%");
            }
            //农村住宅石木总面积
            long villageStoneWoodArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅石木总面积占比
            StringBuilder villageStoneWoodAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageStoneWoodArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageStoneWoodAreaProportion=new StringBuilder();
                villageStoneWoodAreaProportion.append(format+"%");
            }
            //农村公共建筑石木总面积
            long villagePubStoneWoodArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑石木总面积占比
            StringBuilder villagePubStoneWoodAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubStoneWoodArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubStoneWoodAreaProportion=new StringBuilder();
                villagePubStoneWoodAreaProportion.append(format+"%");
            }
            //本报告木结构
            analysisQueryVo.setStructureType("木结构");
            //农村住宅木结构总数
            long villageWoodStructureNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅木结构总数占比
            StringBuilder villageWoodStructureNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageWoodStructureNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageWoodStructureNumProportion=new StringBuilder();
                villageWoodStructureNumProportion.append(format+"%");
            }
            //农村公共建筑木结构总数
            long villagePubWoodStructureNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑木结构总数占比
            StringBuilder villagePubWoodStructureNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubWoodStructureNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubWoodStructureNumProportion=new StringBuilder();
                villagePubWoodStructureNumProportion.append(format+"%");
            }
            //农村住宅木结构总面积
            long villageWoodStructureArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅木结构总面积占比
            StringBuilder villageWoodStructureAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageWoodStructureArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageWoodStructureAreaProportion=new StringBuilder();
                villageWoodStructureAreaProportion.append(format+"%");
            }
            //农村公共建筑木结构总面积
            long villagePubWoodStructureArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑木结构总面积占比
            StringBuilder villagePubWoodStructureAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubWoodStructureArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubWoodStructureAreaProportion=new StringBuilder();
                villagePubWoodStructureAreaProportion.append(format+"%");
            }
            //本报告窑洞
            analysisQueryVo.setStructureType("窑洞");
            //农村住宅窑洞总数
            long villageCaveDwellingNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅窑洞总数占比
            StringBuilder villageCaveDwellingNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageCaveDwellingNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageCaveDwellingNumProportion=new StringBuilder();
                villageCaveDwellingNumProportion.append(format+"%");
            }
            //农村公共建筑窑洞总数
            long villagePubCaveDwellingNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑窑洞总数占比
            StringBuilder villagePubCaveDwellingNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubCaveDwellingNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubCaveDwellingNumProportion=new StringBuilder();
                villagePubCaveDwellingNumProportion.append(format+"%");
            }
            //农村住宅窑洞总面积
            long villageCaveDwellingArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅窑洞总面积占比
            StringBuilder villageCaveDwellingAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageCaveDwellingArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageCaveDwellingAreaProportion=new StringBuilder();
                villageCaveDwellingAreaProportion.append(format+"%");
            }
            //农村公共建筑窑洞总面积
            long villagePubCaveDwellingArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑窑洞总面积占比
            StringBuilder villagePubCaveDwellingAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubCaveDwellingArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubCaveDwellingAreaProportion=new StringBuilder();
                villagePubCaveDwellingAreaProportion.append(format+"%");
            }
            //本报告混杂结构（砖/砌块/土/石）
            analysisQueryVo.setStructureType("混杂结构（砖/砌块/土/石）");
            //农村住宅混杂结构（砖/砌块/土/石）总数
            long villageMixedStructureNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅混杂结构（砖/砌块/土/石）总数占比
            StringBuilder villageMixedStructureNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageMixedStructureNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageMixedStructureNumProportion=new StringBuilder();
                villageMixedStructureNumProportion.append(format+"%");
            }
            //农村公共建筑混杂结构（砖/砌块/土/石）总数
            long villagePubMixedStructureNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑混杂结构（砖/砌块/土/石）总数占比
            StringBuilder villagePubMixedStructureNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubMixedStructureNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubMixedStructureNumProportion=new StringBuilder();
                villagePubMixedStructureNumProportion.append(format+"%");
            }
            //农村住宅混杂结构（砖/砌块/土/石）总面积
            long villageMixedStructureArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅混杂结构（砖/砌块/土/石）总面积占比
            StringBuilder villageMixedStructureAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageMixedStructureArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageMixedStructureAreaProportion=new StringBuilder();
                villageMixedStructureAreaProportion.append(format+"%");
            }
            //农村公共建筑混杂结构（砖/砌块/土/石）总面积
            long villagePubMixedStructureArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑混杂结构（砖/砌块/土/石）总面积占比
            StringBuilder villagePubMixedStructureAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubMixedStructureArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubMixedStructureAreaProportion=new StringBuilder();
                villagePubMixedStructureAreaProportion.append(format+"%");
            }
            //本报告其它
            analysisQueryVo.setStructureType("其它");
            //农村住宅其它总数
            long villageOtherNum=villageHouseFormService.count(analysisQueryVo);
            //农村住宅其它总数占比
            StringBuilder villageOtherNumProportion=null;
            //农村住宅总数必须大于0
            if(countVillage>0){
                double villageBrick=(villageOtherNum/(double)countVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageOtherNumProportion=new StringBuilder();
                villageOtherNumProportion.append(format+"%");
            }
            //农村公共建筑其它总数
            long villagePubOtherNum=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑其它总数占比
            StringBuilder villagePubOtherNumProportion=null;
            //农村公共建筑总数必须大于0
            if(countVillagePub>0){
                double villagePubBrick=(villagePubOtherNum/(double)countVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubOtherNumProportion=new StringBuilder();
                villagePubOtherNumProportion.append(format+"%");
            }
            //农村住宅其它总面积
            long villageOtherArea=villageHouseFormService.count(analysisQueryVo);
            //农村住宅其它总面积占比
            StringBuilder villageOtherAreaProportion=null;
            //农村住宅面积总数必须大于0
            if(areaVillage>0){
                double villageBrick=(villageOtherArea/(double)areaVillage)*100;
                String format = String.format("%.2f", villageBrick);
                villageOtherAreaProportion=new StringBuilder();
                villageOtherAreaProportion.append(format+"%");
            }
            //农村公共建筑其它总面积
            long villagePubOtherArea=villagePubHouseFormService.count(analysisQueryVo);
            //农村公共建筑其它总面积占比
            StringBuilder villagePubOtherAreaProportion=null;
            //农村公共建筑面积总数必须大于0
            if(areaVillagePub>0){
                double villagePubBrick=(villagePubOtherArea/(double)areaVillagePub)*100;
                String format = String.format("%.2f", villagePubBrick);
                villagePubOtherAreaProportion=new StringBuilder();
                villagePubOtherAreaProportion.append(format+"%");
            }
            //获取最小纬度
            Float minLatitude = Collections.min(latitude);
            //获取最大纬度
            Float maxLatitude = Collections.max(latitude);
            //获取最小经度
            Float minLongitude = Collections.min(longitude);
            //获取最大纬度
            Float maxLongitude = Collections.max(longitude);
            //获取当前用户Id
            String userId = PlatformSessionUtils.getUserId();
            //获取当前用户信息
            UserEntity user = PlatformAPI.getOrgAPI().getUserAPI().getUser(userId);
            //获取最小时间
            String minTime = DateUtils.getMinTime(listDate);
            //获取最大时间
            String maxTime = DateUtils.getMaxTime(listDate);
            //获取相差天数
            long countDay = DateUtils.getDay(minTime, maxTime);
            //一个任务对应一个小组所以它们是等值的
            //任务id去重
            listTaskId = new ArrayList<>(new TreeSet<>(listTaskId));
            int groupCount = listTaskId.size();
            //根据任务Id查询任务
            List<FwTaskEntity> formEntities = taskService.findByIds(listTaskId);
            //取出领导ID
            formEntities.forEach(fwTaskEntity -> {
                listLeaderId.add(fwTaskEntity.getGroupLeaderId());
                listGroupId.add(fwTaskEntity.getGroupId());
            });
            //将组长id去重
            List<String> onlyLeaderId=new ArrayList<>(new TreeSet<>(listLeaderId));
            //小组id去重
            List<String> onlyGroupId=new ArrayList<>(new TreeSet<>(listGroupId));
            List<FwGroupEntity> groupList = fwGroupService.findListById(onlyGroupId);
            //小组成员Id
            List<String> listGroupUserId=new ArrayList<>();
            //获取小组成员
            for(String groupId:onlyGroupId){
                List<FwGroupUserEntity> groupUser = fwGroupUserService.findByGroupId(groupId);
                for(FwGroupUserEntity fwGroupUserEntity: groupUser){
                    listGroupUserId.add(fwGroupUserEntity.getUserId());
                }
            }
            //利用hashSet的去重特性
            HashSet<String> hashSet=new HashSet<>();
            hashSet.addAll(listGroupUserId);
            //清空原有的元素数组，放入去重后的元素
            listGroupUserId.clear();
            listGroupUserId.addAll(hashSet);
            //移除组员id中包含组长的id
            listGroupUserId.removeAll(onlyLeaderId);
            //再将组长Id和组员Id并集
            listGroupUserId.addAll(onlyLeaderId);
            //工作区建筑物总数统计图获取
            String imageWorkNumPath = configBeanValue.wordImage + "/" + timeStamp +"buildingWorkspace1.png";
            //获取工作区建筑物总数统计图base64
            String buildingCountImageNum = ImageUtil.getImageBase(imageWorkNumPath);
            //工作区建筑物总数统计图获取
            String imageWorkAreaPath = configBeanValue.wordImage + "/" + timeStamp +"buildingWorkspace2.png";
            //获取工作区建筑物总数统计图base64
            String buildingCountImageArea = ImageUtil.getImageBase(imageWorkAreaPath);

            //城镇房屋设施结构类型占比统计图获取
            String imageCityStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"cityBuildingsArea.png";
            //城镇房屋设施结构类型占比统计图base64
            String imageCityStructureArea= ImageUtil.getImageBase(imageCityStructureAreaPath);
            String imageCityStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"cityBuildingsNum.png";
            //城镇房屋设施结构类型占比统计图base64
            String imageCityStructureNum= ImageUtil.getImageBase(imageCityStructureNumPath);

            /*//城镇房屋（非住宅）设施结构类型占比统计图获取
            String imageNoCityStructurePath = configBeanValue.wordImage + "/" + timeStamp +"城镇房屋（非住宅）设施结构类型占比统计图.png";
            //城镇房屋（非住宅）设施结构类型占比统计图base64
            String imageNoCityStructure= ImageUtil.getImageBase(imageNoCityStructurePath);*/

            //农村住宅结构类型占比统计图获取
            String imageVillageStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralBuildingsArea.png";
            //农村住宅结构类型占比统计图base64
            String imageVillageStructureArea= ImageUtil.getImageBase(imageVillageStructureAreaPath);
            String imageVillageStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"ruralBuildingsNum.png";
            //农村住宅结构类型占比统计图base64
            String imageVillageStructureNum= ImageUtil.getImageBase(imageVillageStructureNumPath);
           /* //农村公共建筑结构类型占比统计图获取
            String imageVillagePubStructurePath = configBeanValue.wordImage + "/" + timeStamp +"农村公共建筑结构类型占比统计图.png";
            //农村公共建筑结构类型占比统计图base64
            String imageVillagePubStructure= ImageUtil.getImageBase(imageVillagePubStructurePath);*/

            //城镇住宅建造年代占比统计图
            String imageCityYearStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"cityBuildingsAgeArea.png";
            //城镇住宅建造年代占比统计图base64
            String imageCityYearArea= ImageUtil.getImageBase(imageCityYearStructureAreaPath);
            String imageCityYearStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"cityBuildingsAgeNum.png";
            //城镇住宅建造年代占比统计图base64
            String imageCityYearNum= ImageUtil.getImageBase(imageCityYearStructureNumPath);

            //城镇房屋设施（非住宅）建造年代占比统计图
            String imageNoCityYearStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ucityBuildingsAgeArea.png";
            //城镇住宅建造年代占比统计图base64
            String imageNoCityYearArea= ImageUtil.getImageBase(imageNoCityYearStructureAreaPath);
            String imageNoCityYearStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"ucityBuildingsAgeNum.png";
            //城镇住宅建造年代占比统计图base64
            String imageNoCityYearNum= ImageUtil.getImageBase(imageNoCityYearStructureNumPath);

            //农村住房建造年代占比统计图
            String imageVillageYearStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralBuildingsAgeArea.png";
            //农村住房建造年代占比统计图base64
            String imageVillageYearArea= ImageUtil.getImageBase(imageVillageYearStructureAreaPath);
            String imageVillageYearStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"ruralBuildingsAgeNum.png";
            //农村住房建造年代占比统计图base64
            String imageVillageYearNum= ImageUtil.getImageBase(imageVillageYearStructureNumPath);

            //农村住房建造年代占比统计图
            String imageVillagePubYearStructureAreaPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralBuildingsAgeArea.png";
            //农村住房建造年代占比统计图base64
            String imageVillagePubYearArea= ImageUtil.getImageBase(imageVillagePubYearStructureAreaPath);
            String imageVillagePubYearStructureNumPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralBuildingsAgeNum.png";
            //农村住房建造年代占比统计图base64
            String imageVillagePubYearNum= ImageUtil.getImageBase(imageVillagePubYearStructureNumPath);

            //城镇住宅抗震设防烈度占比统计图
            String imageCityFortificationIntensityAreaPath = configBeanValue.wordImage + "/" + timeStamp +"cityEarthquakeArea.png";
            //城镇住宅抗震设防烈度占比统计图base64
            String imageCityFortificationIntensityArea= ImageUtil.getImageBase(imageCityFortificationIntensityAreaPath);
            String imageCityFortificationIntensityNumPath = configBeanValue.wordImage + "/" + timeStamp +"cityEarthquakeNum.png";
            //城镇住宅抗震设防烈度占比统计图base64
            String imageCityFortificationIntensityNum= ImageUtil.getImageBase(imageCityFortificationIntensityNumPath);

            //城镇房屋设施（非住宅）抗震设防烈度占比统计图
            String imageNoCityFortificationIntensityAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ucityEarthquakeArea.png";
            //城镇房屋设施（非住宅）抗震设防烈度占比统计图base64
            String imageNoCityFortificationIntensityArea= ImageUtil.getImageBase(imageNoCityFortificationIntensityAreaPath);
            String imageNoCityFortificationIntensityNumPath = configBeanValue.wordImage + "/" + timeStamp +"ucityEarthquakeNum.png";
            //城镇房屋设施（非住宅）抗震设防烈度占比统计图base64
            String imageNoCityFortificationIntensityNum= ImageUtil.getImageBase(imageNoCityFortificationIntensityNumPath);

            //农村公共建筑抗震设防烈度占比统计图
            String imageVillagePubFortificationIntensityAreaPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralEarthquakeArea.png";
            //农村公共建筑抗震设防烈度占比统计图base64
            String imageVillagePubFortificationIntensityArea= ImageUtil.getImageBase(imageVillagePubFortificationIntensityAreaPath);
            String imageVillagePubFortificationIntensityNumPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralEarthquakeNum.png";
            //农村公共建筑抗震设防烈度占比统计图base64
            String imageVillagePubFortificationIntensityNum= ImageUtil.getImageBase(imageVillagePubFortificationIntensityNumPath);

            //农村住宅建筑抗震设防烈度占比统计图
            String imageVillageFortificationIntensityAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralEarthquakeArea.png";
            //农村住宅抗震设防烈度占比统计图base64
            String imageVillageFortificationIntensityArea= ImageUtil.getImageBase(imageVillageFortificationIntensityAreaPath);
            //农村住宅建筑抗震设防烈度占比统计图
            String imageVillageFortificationIntensityPathNum = configBeanValue.wordImage + "/" + timeStamp +"ruralEarthquakeNum.png";
            //农村住宅抗震设防烈度占比统计图base64
            String imageVillageFortificationIntensityNum= ImageUtil.getImageBase(imageVillageFortificationIntensityPathNum);

            //农村居住房屋抗震构造措施占比统计图
            String imageVillageHouseMeasuresAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralStructureArea.png";
            //农村居住房屋抗震构造措施占比统计图base64
            String imageVillageHouseMeasuresArea= ImageUtil.getImageBase(imageVillageHouseMeasuresAreaPath);
            String imageVillageHouseMeasuresNumPath = configBeanValue.wordImage + "/" + timeStamp +"ruralStructureNum.png";
            //农村居住房屋抗震构造措施占比统计图base64
            String imageVillageHouseMeasuresNum= ImageUtil.getImageBase(imageVillageHouseMeasuresNumPath);

            //农村居住房屋曾受灾情况占比统计图
            String imageVillageHouseDisasterAreaPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralDisastersArea.png";
            //农村居住房屋曾受灾情况占比统计图base64--面积
            String imageVillageHouseDisasterArea= ImageUtil.getImageBase(imageVillageHouseDisasterAreaPath);
            String imageVillageHouseDisasterNumPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralDisastersNum.png";
            //农村居住房屋曾受灾情况占比统计图base64--数量
            String imageVillageHouseDisasterNum= ImageUtil.getImageBase(imageVillageHouseDisasterNumPath);

            //城镇住宅抗震设防情况占比统计图
            String imageCitySeismicFortificationAreaPath = configBeanValue.wordImage + "/" + timeStamp +"citySituationArea.png";
            //城镇住宅抗震设防情况占比统计图base64
            String imageCitySeismicFortificationArea= ImageUtil.getImageBase(imageCitySeismicFortificationAreaPath);
            String imageCitySeismicFortificationNumPath = configBeanValue.wordImage + "/" + timeStamp +"citySituationNum.png";
            //城镇住宅抗震设防情况占比统计图base64
            String imageCitySeismicFortificationNum= ImageUtil.getImageBase(imageCitySeismicFortificationNumPath);

            //城镇住宅安全隐患占比统计图
            String imageCitySafeHiddenAreaPath = configBeanValue.wordImage + "/" + timeStamp +"cityhiddenDangerArea.png";
            //城镇住宅安全隐患占比统计图base64
            String imageCitySafeHiddenArea= ImageUtil.getImageBase(imageCitySafeHiddenAreaPath);
            String imageCitySafeHiddenNumPath = configBeanValue.wordImage + "/" + timeStamp +"cityhiddenDangerNum.png";
            //城镇住宅安全隐患占比统计图base64
            String imageCitySafeHiddenNum= ImageUtil.getImageBase(imageCitySafeHiddenNumPath);

            //城镇房屋设施（非住宅）抗震设防情况占比统计图
            String imageNoCitySeismicFortificationAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ucitySituationArea.png";
            //城镇房屋设施（非住宅）抗震设防情况占比统计图base64
            String imageNoCitySeismicFortificationArea= ImageUtil.getImageBase(imageNoCitySeismicFortificationAreaPath);
            String imageNoCitySeismicFortificationNumPath = configBeanValue.wordImage + "/" + timeStamp +"ucitySituationNum.png";
            //城镇房屋设施（非住宅）抗震设防情况占比统计图base64
            String imageNoCitySeismicFortificationNum= ImageUtil.getImageBase(imageNoCitySeismicFortificationNumPath);

            //城镇房屋设施（非住宅）安全隐患占比统计图
            String imageNoCitySafeHiddenAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ucityhiddenDangerArea.png";
            //城镇房屋设施（非住宅）安全隐患占比统计图base64--面积
            String imageNoCitySafeHiddenArea= ImageUtil.getImageBase(imageNoCitySafeHiddenAreaPath);
            String imageNoCitySafeHiddenNumPath = configBeanValue.wordImage + "/" + timeStamp +"ucityhiddenDangerNum.png";
            //城镇房屋设施（非住宅）安全隐患占比统计图base64--数量
            String imageNoCitySafeHiddenNum= ImageUtil.getImageBase(imageNoCitySafeHiddenNumPath);

            //农村住房抗震设防情况占比统计图
            String imageVillageSeismicFortificationAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralSituationArea.png";
            //农村住房抗震设防情况占比统计图base64--面积
            String imageVillageSeismicFortificationArea= ImageUtil.getImageBase(imageVillageSeismicFortificationAreaPath);
            String imageVillageSeismicFortificationNumPath = configBeanValue.wordImage + "/" + timeStamp +"ruralSituationNum.png";
            //农村住房抗震设防情况占比统计图base64--数量
            String imageVillageSeismicFortificationNum= ImageUtil.getImageBase(imageVillageSeismicFortificationNumPath);

            //农村住房安全隐患占比统计图
            String imageVillageSafeHiddenAreaPath = configBeanValue.wordImage + "/" + timeStamp +"ruralhiddenDangerArea.png";
            //农村住房安全隐患占比统计图base64--面积
            String imageVillageSafeHiddenArea= ImageUtil.getImageBase(imageVillageSafeHiddenAreaPath);
            String imageVillageSafeHiddenNumPath = configBeanValue.wordImage + "/" + timeStamp +"ruralhiddenDangerNum.png";
            //农村住房安全隐患占比统计图base64--数量
            String imageVillageSafeHiddenNum= ImageUtil.getImageBase(imageVillageSafeHiddenNumPath);

            //农村公共建筑抗震设防情况占比统计图
            String imageVillagePubSeismicFortificationAreaPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralSituationArea.png";
            //农村公共建筑抗震设防情况占比统计图base64--面积
            String imageVillagePubSeismicFortificationArea= ImageUtil.getImageBase(imageVillagePubSeismicFortificationAreaPath);
            //农村公共建筑抗震设防情况占比统计图
            String imageVillagePubSeismicFortificationNumPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralSituationNum.png";
            //农村公共建筑抗震设防情况占比统计图base64--数量
            String imageVillagePubSeismicFortificationNum= ImageUtil.getImageBase(imageVillagePubSeismicFortificationNumPath);

            //农村公共建筑安全隐患占比统计图
            String imageVillagePubSafeHiddenAreaPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralhiddenDangerArea.png";
            //农村公共建筑安全隐患占比统计图base64--面积
            String imageVillagePubSafeHiddenArea= ImageUtil.getImageBase(imageVillagePubSafeHiddenAreaPath);
            //农村公共建筑安全隐患占比统计图
            String imageVillagePubSafeHiddenNumPath = configBeanValue.wordImage + "/" + timeStamp +"pbruralhiddenDangerNum.png";
            //农村公共建筑安全隐患占比统计图base64--数量
            String imageVillagePubSafeHiddenNum= ImageUtil.getImageBase(imageVillagePubSafeHiddenNumPath);

            Map<String, Object> map = new HashMap<>();
            //当前年
            map.put("year", year);
            //当前月
            map.put("month", month);
            //当前日
            map.put("day", day);
            //包含的区
            map.put("areaArray", areaArray);
            //最小纬度
            map.put("latitudeSmall", minLatitude);
            //最大纬度
            map.put("latitudeBig", maxLatitude);
            //最小经度
            map.put("longitudeSmall",minLongitude );
            //最大经度
            map.put("longitudeBig",maxLongitude);
            //报告人
            map.put("userName", user.getUserName());
            //报告省份
            map.put("province", province);
            if(StringUtils.isEmpty(city)) {
                //报告市级
                map.put("city", "");
            }else {
                map.put("city", city);
            }
            //建筑面积
            map.put("area",areaCount);
            //起始时间
            map.put("startDate",minTime);
            //结束时间
            map.put("endDate",maxTime);
            //总天数
            map.put("countDay",countDay);
            //小组总数
            map.put("groupCount",groupCount);
            //小组列表
            map.put("groupList",groupList);
            //小组总数
            map.put("userCount",listGroupUserId.size());
            //本次采集总栋数
            map.put("countNum",countNum);
            //房屋总面积
            map.put("countArea",areaNum);
            //城镇住宅总数
            map.put("cityNum",countCity);
            //城镇住宅面积总数
            map.put("cityArea",areaCity);
            //城镇非住宅总数
            map.put("noCityNum",countNoCity);
            //城镇非住宅面积总数
            map.put("noCityArea",areaNoCity);
            //农村住房总数
            map.put("villageHouseNum",countVillage);
            //农村住房总面积
            map.put("villageHouseArea",areaVillagePub);
            //农村公共建筑总数
            map.put("villagePubHouseNum",countVillagePub);
            //农村公共建筑面积
            map.put("villagePubHouseArea",areaVillagePub);
            //工作区建筑物总数统计图
            map.put("buildingCountImageNum",buildingCountImageNum);
            //工作区建筑物总数统计图
            map.put("buildingCountImageArea",buildingCountImageArea);
            //城镇房屋设施结构类型占比统计图
            map.put("imageCityStructureArea",imageCityStructureArea);
            map.put("imageCityStructureNum",imageCityStructureNum);
           /* //城镇房屋（非住宅）设施结构类型占比统计图
            map.put("imageNoCityStructure",imageNoCityStructure);*/
            //农村住宅结构类型占比统计图
            map.put("imageVillageStructureArea",imageVillageStructureArea);
            map.put("imageVillageStructureNum",imageVillageStructureNum);
           /* //农村公共建筑结构类型占比统计图
            map.put("imageVillagePubStructure",imageVillagePubStructure);*/
            //城镇住宅建造年代占比统计图
            map.put("imageCityYearArea",imageCityYearArea);
            map.put("imageCityYearNum",imageCityYearNum);
            //城镇房屋设施（非住宅）建造年代占比统计图
            map.put("imageNoCityYearArea",imageNoCityYearArea);
            map.put("imageNoCityYearNum",imageNoCityYearNum);
            //农村住房建造年代占比统计图
            map.put("imageVillageYearArea",imageVillageYearArea);
            map.put("imageVillageYearNum",imageVillageYearNum);
            //农村公共建筑建造年代占比统计图
            map.put("imageVillagePubYearArea",imageVillagePubYearArea);
            map.put("imageVillagePubYearNum",imageVillagePubYearNum);
            //城镇住宅抗震设防烈度占比统计图
            map.put("imageCityFortificationIntensityArea",imageCityFortificationIntensityArea);
            map.put("imageCityFortificationIntensityNum",imageCityFortificationIntensityNum);
            //城镇房屋设施（非住宅）抗震设防烈度占比统计图
            map.put("imageNoCityFortificationIntensityArea",imageNoCityFortificationIntensityArea);
            map.put("imageNoCityFortificationIntensityNum",imageNoCityFortificationIntensityNum);
            //农村住宅抗震设防烈度占比统计图
            map.put("imageVillageFortificationIntensityArea",imageVillageFortificationIntensityArea);
            map.put("imageVillageFortificationIntensityNum",imageVillageFortificationIntensityNum);
            //农村公共建筑抗震设防烈度占比统计图
            map.put("imageVillagePubFortificationIntensityArea",imageVillagePubFortificationIntensityArea);
            map.put("imageVillagePubFortificationIntensityNum",imageVillagePubFortificationIntensityNum);
            //农村居住房屋抗震构造措施占比统计图
            map.put("imageVillageHouseMeasuresArea",imageVillageHouseMeasuresArea);
            map.put("imageVillageHouseMeasuresNum",imageVillageHouseMeasuresNum);
            //农村居住房屋曾受灾情况占比统计图
            map.put("imageVillageHouseDisasterArea",imageVillageHouseDisasterArea);
            map.put("imageVillageHouseDisasterNum",imageVillageHouseDisasterNum);
            //城镇住宅抗震设防情况占比统计图
            map.put("imageCitySeismicFortificationArea",imageCitySeismicFortificationArea);
            map.put("imageCitySeismicFortificationNum",imageCitySeismicFortificationNum);
            //城镇住宅安全隐患占比统计图
            map.put("imageCitySafeHiddenArea",imageCitySafeHiddenArea);
            map.put("imageCitySafeHiddenNum",imageCitySafeHiddenNum);
            //城镇房屋设施（非住宅）抗震设防情况占比统计图
            map.put("imageNoCitySeismicFortificationArea",imageNoCitySeismicFortificationArea);
            map.put("imageNoCitySeismicFortificationNum",imageNoCitySeismicFortificationNum);
            //城镇房屋设施（非住宅）安全隐患占比统计图
            map.put("imageNoCitySafeHiddenArea",imageNoCitySafeHiddenArea);
            map.put("imageNoCitySafeHiddenNum",imageNoCitySafeHiddenNum);
            //农村住房抗震设防情况占比统计图
            map.put("imageVillageSeismicFortificationArea",imageVillageSeismicFortificationArea);
            map.put("imageVillageSeismicFortificationNum",imageVillageSeismicFortificationNum);
            //农村住房安全隐患占比统计图
            map.put("imageVillageSafeHiddenArea",imageVillageSafeHiddenArea);
            map.put("imageVillageSafeHiddenNum",imageVillageSafeHiddenNum);
            //农村公共建筑抗震设防情况占比统计图
            map.put("imageVillagePubSeismicFortificationArea",imageVillagePubSeismicFortificationArea);
            map.put("imageVillagePubSeismicFortificationNum",imageVillagePubSeismicFortificationNum);
            //农村公共建筑安全隐患占比统计图
            map.put("imageVillagePubSafeHiddenArea",imageVillagePubSafeHiddenArea);
            map.put("imageVillagePubSafeHiddenNum",imageVillagePubSafeHiddenNum);
            //城镇住宅砖混建筑数量
            map.put("cityBrickMixNum",cityBrickMixNum);
            //城镇住宅砖混建筑数量占比
            if(StringUtils.isEmpty(cityBrickMixNumProportion)){
                map.put("cityBrickMixNumProportion","0.00%");
            }else {
                map.put("cityBrickMixNumProportion",cityBrickMixNumProportion);
            }
            //城镇住宅砖混建筑面积
            map.put("cityBrickMixArea",cityBrickMixArea);
            //城镇住宅砖混建筑面积占比
            if(StringUtils.isEmpty(cityBrickMixAreaProportion)){
                map.put("cityBrickMixAreaProportion","0.00%");
            }else {
                map.put("cityBrickMixAreaProportion",cityBrickMixAreaProportion);
            }
            //城镇住宅底层混凝土柱-上部砖混结构建筑总数
            map.put("cityTopBrickNum",cityTopBrickNum);
            //城镇住宅底层混凝土柱-上部砖混结构建筑总数占比
            if(StringUtils.isEmpty(cityTopBrickNumProportion)){
               map.put("cityTopBrickNumProportion","0.00%");
            }else {
                map.put("cityTopBrickNumProportion",cityTopBrickNumProportion);
            }
            //城镇住宅底层混凝土柱-上部砖混结构建筑总数
            map.put("cityTopBrickArea",cityTopBrickArea);
            //城镇住宅底层混凝土柱-上部砖混结构面积占比
            if(StringUtils.isEmpty(cityTopBrickAreaProportion)){
                map.put("cityTopBrickAreaProportion","0.00%");
            }else {
                map.put("cityTopBrickAreaProportion",cityTopBrickAreaProportion);
            }
            //城镇住宅钢筋混凝土建筑总数
            map.put("cityReinforcedConcreteNum",cityReinforcedConcreteNum);
            //城镇住宅钢筋混凝土建筑占比
            if(StringUtils.isEmpty(cityReinforcedConcreteNumProportion)){
                map.put("cityReinforcedConcreteNumProportion","0.00%");
            }else {
                map.put("cityReinforcedConcreteNumProportion",cityReinforcedConcreteNumProportion);
            }
            //城镇住宅钢筋混凝土面积总数
            map.put("cityReinforcedConcreteArea",cityReinforcedConcreteArea);
            //城镇住宅钢筋混凝土建筑面积占比
            if(StringUtils.isEmpty(cityReinforcedConcreteAreaProportion)){
                map.put("cityReinforcedConcreteAreaProportion","0.00%");
            }else {
                map.put("cityReinforcedConcreteAreaProportion",cityReinforcedConcreteAreaProportion);
            }
            //城镇住宅砖木建筑总数
            map.put("cityBrickWoodNum",cityBrickWoodNum);
            //城镇住宅砖木总数占比
            if(StringUtils.isEmpty(cityBrickWoodNumProportion)){
                map.put("cityBrickWoodNumProportion","0.00%");
            }else {
                map.put("cityBrickWoodNumProportion",cityBrickWoodNumProportion);
            }
            //城镇住宅砖木建筑面积总数
            map.put("cityBrickWoodArea",cityBrickWoodArea);
            //城镇住宅砖木建筑面积占比
            if(StringUtils.isEmpty(cityBrickWoodAreaProportion)){
                map.put("cityBrickWoodAreaProportion","0.00%");
            }else {
                map.put("cityBrickWoodAreaProportion",cityBrickWoodAreaProportion);
            }
            //城镇住宅钢结构建筑总数
            map.put("citySteelStructureNum",citySteelStructureNum);
            //城镇住宅钢结构建筑占比
            if(StringUtils.isEmpty(citySteelStructureNumProportion)){
                map.put("citySteelStructureNumProportion","0.00%");
            }else {
                map.put("citySteelStructureNumProportion",citySteelStructureNumProportion);
            }
            //城镇住宅钢结构面积总数
            map.put("citySteelStructureArea",citySteelStructureArea);
            //城镇住宅钢结构面积占比
            if(StringUtils.isEmpty(citySteelStructureAreaProportion)){
                map.put("citySteelStructureAreaProportion","0.00%");
            }else {
                map.put("citySteelStructureAreaProportion",citySteelStructureAreaProportion);
            }
            //城镇住宅木结构建筑总数
            map.put("cityWoodStructureNum",cityWoodStructureNum);
            //城镇住宅木结构建筑占比
            if(StringUtils.isEmpty(cityWoodStructureNumProportion)){
                map.put("cityWoodStructureNumProportion","0.00%");
            }else {
                map.put("cityWoodStructureNumProportion",cityWoodStructureNumProportion);
            }
            //城镇住宅木结构面积总数
            map.put("cityWoodStructureArea",cityWoodStructureArea);
            //城镇住宅钢结构面积占比
            if(StringUtils.isEmpty(cityWoodStructureAreaProportion)){
                map.put("cityWoodStructureAreaProportion","0.00%");
            }else {
                map.put("cityWoodStructureAreaProportion",cityWoodStructureAreaProportion);
            }
            //城镇住宅其他建筑总数
            map.put("cityOtherNum",cityOtherNum);
            //城镇住宅其他建筑占比
            if(StringUtils.isEmpty(cityOtherNumProportion)){
                map.put("cityOtherNumProportion","0.00%");
            }else {
                map.put("cityOtherNumProportion",cityOtherNumProportion);
            }
            //城镇住宅其他建筑面积总数
            map.put("cityOtherArea",cityOtherArea);
            //城镇住宅其他建筑面积占比
            if(StringUtils.isEmpty(cityOtherAreaProportion)){
                map.put("cityOtherAreaProportion","0.00%");
            }else {
                map.put("cityOtherAreaProportion",cityOtherAreaProportion);
            }
            //城镇非住宅砖混建筑总数
            map.put("nocityBrickMixNum",nocityBrickMixNum);
            //城镇住宅砖混建筑总数占比
            if(StringUtils.isEmpty(nocityBirckMixProportion)){
                map.put("nocityBirckMixProportion","0.00%");
            }else {
                map.put("nocityBirckMixProportion",nocityBirckMixProportion);
            }
            //城镇非住宅砖混建筑面积总数
            map.put("nocityBrickMixArea",nocityBrickMixArea);
            //城镇住宅砖混建筑总数占比
            if(StringUtils.isEmpty(nocityBrickMixAreaProportion)){
                map.put("nocityBrickMixAreaProportion","0.00%");
            }else {
                map.put("nocityBrickMixAreaProportion",nocityBrickMixAreaProportion);
            }
            //城镇非住宅底层混凝土柱-上部砖混结构建筑总数
            map.put("nocityTopBrickNum",nocityTopBrickNum);
            //城镇非住宅底层混凝土柱-上部砖混结构建筑总数占比
            if(StringUtils.isEmpty(nocityTopBrickNumProportion)){
                map.put("nocityTopBrickNumProportion","0.00%");
            }else {
                map.put("nocityTopBrickNumProportion",nocityTopBrickNumProportion);
            }
            //城镇非住宅底层混凝土柱-上部砖混结构面积总数
            map.put("nocityTopBrickArea",nocityTopBrickArea);
            //城镇非住宅底层混凝土柱-上部砖混结构面积总数占比
            if(StringUtils.isEmpty(nocityTopBrickAreaProportion)){
                map.put("nocityTopBrickAreaProportion","0.00%");
            }else {
                map.put("nocityTopBrickAreaProportion",nocityTopBrickAreaProportion);
            }
            //城镇非住宅钢筋混凝土建筑总数
            map.put("nocityReinforcedConcreteNum",nocityReinforcedConcreteNum);
            //城镇非住宅钢筋混凝土建筑总数占比
            if(StringUtils.isEmpty(nocityReinforcedConcreteNumProportio)){
                map.put("nocityReinforcedConcreteNumProportion","0.00%");
            }else {
                map.put("nocityReinforcedConcreteNumProportion",nocityReinforcedConcreteNumProportio);
            }
            //城镇非住宅钢筋混凝土建筑面积总数
            map.put("nocityReinforcedConcreteArea",nocityReinforcedConcreteArea);
            //城镇非住宅钢筋混凝土建筑面积总数占比
            if(StringUtils.isEmpty(nocityReinforcedConcreteAreaProportion)){
                map.put("nocityReinforcedConcreteAreaProportion","0.00%");
            }else {
                map.put("nocityReinforcedConcreteAreaProportion",nocityReinforcedConcreteAreaProportion);
            }
            //城镇非住宅砖木建筑总数
            map.put("nocityBrickWoodNum",nocityBrickWoodNum);
            //城镇非住宅砖木建筑总数占比
            if(StringUtils.isEmpty(nocityBrickWoodNumProportion)){
                map.put("nocityBrickWoodNumProportion","0.00%");
            }else {
                map.put("nocityBrickWoodNumProportion",nocityBrickWoodNumProportion);
            }
            //城镇非住宅砖木建筑总面积
            map.put("nocityBrickWoodArea",nocityBrickWoodArea);
            //城镇非住宅砖木建筑总面积占比
            if(StringUtils.isEmpty(nocityBrickWoodAreaProportion)){
                map.put("nocityBrickWoodAreaProportion","0.00%");
            }else {
                map.put("nocityBrickWoodAreaProportion",nocityBrickWoodAreaProportion);
            }
            //城镇非住宅钢结构建筑总数
            map.put("nocitySteelStructureNum",nocitySteelStructureNum);
            //城镇非住宅钢结构建筑总数占比
            if(StringUtils.isEmpty(nocitySteelStructureNumProportion)){
                map.put("nocitySteelStructureNumProportion","0.00%");
            }else {
                map.put("nocitySteelStructureNumProportion",nocitySteelStructureNumProportion);
            }
            //城镇非住宅钢结构建筑总面积
            map.put("nocitySteelStructureArea",nocitySteelStructureArea);
            //城镇非住宅钢结构建筑总面积占比
            if(StringUtils.isEmpty(nocitySteelStructureAreaProportion)){
                map.put("nocitySteelStructureAreaProportion","0.00%");
            }else {
                map.put("nocitySteelStructureAreaProportion",nocitySteelStructureAreaProportion);
            }
            //城镇非住宅木结构建筑总数
            map.put("nocityWoodStructureNum",nocityWoodStructureNum);
            //城镇非住宅木结构建筑总数占比
            if(StringUtils.isEmpty(nocityWoodStructureNumProportion)){
                map.put("nocityWoodStructureNumProportion","0.00%");
            }else {
                map.put("nocityWoodStructureNumProportion",nocityWoodStructureNumProportion);
            }
            //城镇非住宅木结构建筑总面积
            map.put("nocityWoodStructureArea",nocityWoodStructureArea);
            //城镇非住宅木结构建筑总面积占比
            if(StringUtils.isEmpty(nocityWoodStructureAreaProportion)){
                map.put("nocityWoodStructureAreaProportion","0.00%");
            }else {
                map.put("nocityWoodStructureAreaProportion",nocityWoodStructureAreaProportion);
            }
            //城镇非住宅其它结构建筑总数
            map.put("nocityOtherNum",nocityOtherNum);
            //城镇非住宅其它结构建筑总数占比
            if(StringUtils.isEmpty(nocityOtherNumProportion)){
                map.put("nocityOtherNumProportion","0.00%");
            }else {
                map.put("nocityOtherNumProportion",nocityOtherNumProportion);
            }
            //城镇非住宅其它结构建筑总面积
            map.put("nocityOtherArea",nocityOtherArea);
            //城镇非住宅其它结构建筑总面积占比
            if(StringUtils.isEmpty(nocityOtherAreaProportion)){
                map.put("nocityOtherAreaProportion","0.00%");
            }else {
                map.put("nocityOtherAreaProportion",nocityOtherAreaProportion);
            }
            //农村住宅砖（砌块）混建筑总数
            map.put("villageBrickNum",villageBrickNum);
            //农村住宅砖（砌块）混建筑总数占比
            if(StringUtils.isEmpty(villageBrickNumProportion)){
                map.put("villageBrickNumProportion","0.00%");
            }else {
                map.put("villageBrickNumProportion",villageBrickNumProportion);
            }
            //农村住宅砖（砌块）混建筑面积总数
            map.put("villageBrickArea",villageBrickArea);
            //农村住宅砖（砌块）混建筑面积总数占比
            if(StringUtils.isEmpty(villageBrickAreaProportion)){
                map.put("villageBrickAreaProportion","0.00%");
            }else {
                map.put("villageBrickAreaProportion",villageBrickAreaProportion);
            }
            //农村住房低层框架建筑总数
            map.put("villageLowerFrameNum",villageLowerFrameNum);
            //农村住房低层框架建筑总数占比
            if(StringUtils.isEmpty(villageLowerFrameNumProportion)){
                map.put("villageLowerFrameNumProportion","0.00%");
            }else {
                map.put("villageLowerFrameNumProportion",villageLowerFrameNumProportion);
            }
            //农村住房低层框架面积总数
            map.put("villageLowerFrameArea",villageLowerFrameArea);
            //农村住房低层框架面积总数占比
            if(StringUtils.isEmpty(villageLowerFrameAreaProportion)){
                map.put("villageLowerFrameAreaProportion","0.00%");
            }else {
                map.put("villageLowerFrameAreaProportion",villageLowerFrameAreaProportion);
            }
            //农村住宅轻钢（钢）装配式建筑总数
            map.put("villageSteelAssemblyNum",villageSteelAssemblyNum);
            //农村住宅轻钢（钢）装配式建筑总数占比
            if(StringUtils.isEmpty(villageSteelAssemblyNumProportion)){
                map.put("villageSteelAssemblyNumProportion","0.00%");
            }else {
                map.put("villageSteelAssemblyNumProportion",villageSteelAssemblyNumProportion);
            }
            //农村住宅轻钢（钢）装配式建筑面积总数
            map.put("villageSteelAssemblyArea",villageSteelAssemblyArea);
            //农村住宅轻钢（钢）装配式建筑面积总数占比
            if(StringUtils.isEmpty(villageSteelAssemblyAreaProportion)){
                map.put("villageSteelAssemblyAreaProportion","0.00%");
            }else {
                map.put("villageSteelAssemblyAreaProportion",villageSteelAssemblyAreaProportion);
            }
            //农村住宅混凝土装配式建筑总数
            map.put("villageConcreteAssemblyNum",villageConcreteAssemblyNum);
            //农村住宅混凝土装配式建筑总数占比
            if(StringUtils.isEmpty(villageConcreteAssemblyNumProportion)){
               map.put("villageConcreteAssemblyNumProportion","0.00%");
            }else {
                map.put("villageConcreteAssemblyNumProportion",villageConcreteAssemblyNumProportion);
            }
            //农村住宅混凝土装配式建筑面积总数
            map.put("villageConcreteAssemblyArea",villageConcreteAssemblyArea);
            //农村住宅混凝土装配式建筑面积总数占比
            if(StringUtils.isEmpty(villageConcreteAssemblyAreaProportion)){
                map.put("villageConcreteAssemblyAreaProportion","0.00%");
            }else {
                map.put("villageConcreteAssemblyAreaProportion",villageConcreteAssemblyAreaProportion);
            }
            //农村住宅砖木建筑总数
            map.put("villageBrickWoodNum",villageBrickWoodNum);
            //农村住宅砖木建筑总数占比
            if(StringUtils.isEmpty(villageBrickWoodNumProportion)){
                map.put("villageBrickWoodNumProportion","0.00%");
            }else {
                map.put("villageBrickWoodNumProportion",villageBrickWoodNumProportion);
            }
            //农村住宅砖木建筑面积总数
            map.put("villageBrickWoodArea",villageBrickWoodArea);
            //农村住宅砖木建筑面积总数占比
            if(StringUtils.isEmpty(villageBrickWoodAreaProportion)){
                map.put("villageBrickWoodAreaProportion","0.00%");
            }else {
                map.put("villageBrickWoodAreaProportion",villageBrickWoodAreaProportion);
            }
            //农村住宅土木建筑总数
            map.put("villageCivilWoodNum",villageCivilWoodNum);
            //农村住宅土木建筑总数占比
            if(StringUtils.isEmpty(villageCivilWoodNumProportion)){
                map.put("villageCivilWoodNumProportion","0.00%");
            }else {
                map.put("villageCivilWoodNumProportion",villageCivilWoodNumProportion);
            }
            //农村住宅土木建筑面积总数
            map.put("villageCivilWoodArea",villageCivilWoodArea);
            //农村住宅土木建筑面积总数占比
            if(StringUtils.isEmpty(villageCivilWoodAreaProportion)){
                map.put("villageCivilWoodAreaProportion","0.00%");
            }else {
                map.put("villageCivilWoodAreaProportion",villageCivilWoodAreaProportion);
            }
            //农村住宅石木建筑总数
            map.put("villageStoneWoodNum",villageStoneWoodNum);
            //农村住宅石木建筑总数占比
            if(StringUtils.isEmpty(villageStoneWoodNumProportion)){
                map.put("villageStoneWoodNumProportion","0.00%");
            }else{
                map.put("villageStoneWoodNumProportion",villageStoneWoodNumProportion);
            }
            //农村住宅石木建筑面积总数
            map.put("villageStoneWoodArea",villageStoneWoodArea);
            //农村住宅石木建筑面积总数占比
            if(StringUtils.isEmpty(villageStoneWoodAreaProportion)){
                map.put("villageStoneWoodAreaProportion","0.00%");
            }else{
                map.put("villageStoneWoodAreaProportion",villageStoneWoodAreaProportion);
            }
            //农村住宅木结构建筑数量总数
            map.put("villageWoodStructureNum",villageWoodStructureNum);
            //农村住宅木结构建筑数量总数占比
            if(StringUtils.isEmpty(villageWoodStructureNumProportion)){
                map.put("villageWoodStructureNumProportion","0.00%");
            }else {
                map.put("villageWoodStructureNumProportion",villageWoodStructureNumProportion);
            }
            //农村住房木结构建筑总面积
            map.put("villageWoodStructureArea",villageWoodStructureArea);
            //农村住房木结构建筑总面积占比
            if(StringUtils.isEmpty(villageWoodStructureAreaProportion)){
                map.put("villageWoodStructureAreaProportion","0.00%");
            }else {
                map.put("villageWoodStructureAreaProportion",villageWoodStructureAreaProportion);
            }
            //农村住宅窑洞建筑总数
            map.put("villageCaveDwellingNum",villageCaveDwellingNum);
            //农村住宅窑洞建筑总数占比
            if(StringUtils.isEmpty(villageCaveDwellingNumProportion)){
                map.put("villageCaveDwellingNumProportion","0.00%");
            }else {
                map.put("villageCaveDwellingNumProportion",villageCaveDwellingNumProportion);
            }
            //农村住宅窑洞建筑面积总数
            map.put("villageCaveDwellingArea",villageCaveDwellingArea);
            //农村住宅窑洞建筑面积总数占比
            if(StringUtils.isEmpty(villageCaveDwellingAreaProportion)){
                map.put("villageCaveDwellingAreaProportion","0.00%");
            }else {
                map.put("villageCaveDwellingAreaProportion",villageCaveDwellingAreaProportion);
            }
            //农村住房混杂结构（砖/砌块/土/石）建筑总数量
            map.put("villageMixedStructureNum",villageMixedStructureNum);
            //农村住宅混杂结构（砖/砌块/土/石）建筑总数量占比
            if(StringUtils.isEmpty(villageMixedStructureNumProportion)){
                map.put("villageMixedStructureNumProportion","0.00%");
            }else {
                map.put("villageMixedStructureNumProportion",villageMixedStructureNumProportion);
            }
            //农村住宅混杂结构（砖/砌块/土/石）建筑总面积
            map.put("villageMixedStructureArea",villageMixedStructureArea);
            //农村住宅混杂结构（砖/砌块/土/石）建筑总面积占比
            if(StringUtils.isEmpty(villageMixedStructureAreaProportion)){
                map.put("villageMixedStructureAreaProportion","0.00%");
            }else {
                map.put("villageMixedStructureAreaProportion",villageMixedStructureAreaProportion);
            }
            //农村住房其它建筑总数量
            map.put("villageOtherNum",villageOtherNum);
            //农村住宅其它建筑总数量占比
            if(StringUtils.isEmpty(villageOtherNumProportion)){
                map.put("villageOtherNumProportion","0.00%");
            }else {
                map.put("villageOtherNumProportion",villageOtherNumProportion);
            }
            //农村住宅其它建筑总面积
            map.put("villageOtherArea",villageOtherArea);
            //农村住宅其它建筑总面积占比
            if(StringUtils.isEmpty(villageOtherAreaProportion)){
                map.put("villageOtherAreaProportion","0.00%");
            }else {
                map.put("villageOtherAreaProportion",villageOtherAreaProportion);
            }
            //农村公共建筑砖（砌块）混建筑总数
            map.put("villagePubBrickNum",villagePubBrickNum);
            //农村公共建筑砖（砌块）混建筑总数占比
            if(StringUtils.isEmpty(villagePubBrickNumProportion)){
                map.put("villagePubBrickNumProportion","0.00%");
            }else {
                map.put("villagePubBrickNumProportion",villagePubBrickNumProportion);
            }
            //农村公共建筑砖（砌块）混建筑总面积
            map.put("villagePubBrickArea",villagePubBrickArea);
            //农村住宅筑砖（砌块）混建筑总面积占比
            if(StringUtils.isEmpty(villagePubBrickAreaProportion)){
                map.put("villagePubBrickAreaProportion","0.00%");
            }else {
                map.put("villagePubBrickAreaProportion",villagePubBrickAreaProportion);
            }
            //农村公共建筑低层框架总数
            map.put("villagePubLowerFrameNum",villagePubLowerFrameNum);
            //农村公共建筑低层框架总数占比
            if(StringUtils.isEmpty(villagePubLowerFrameNumProportion)){
                map.put("villagePubLowerFrameNumProportion","0.00%");
            }else {
                map.put("villagePubLowerFrameNumProportion",villagePubLowerFrameNumProportion);
            }
            //农村公共建筑低层框架总面积
            map.put("villagePubLowerFrameArea",villagePubLowerFrameArea);
            //农村公共建筑低层框架总面积占比
            if(StringUtils.isEmpty(villagePubLowerFrameAreaProportion)){
                map.put("villagePubLowerFrameAreaProportion","0.00%");
            }else {
                map.put("villagePubLowerFrameAreaProportion",villagePubLowerFrameAreaProportion);
            }
            //农村公共建筑轻钢（钢）装配式总数
            map.put("villagePubSteelAssemblyNum",villagePubSteelAssemblyNum);
            //农村住宅筑轻钢（钢）装配式总数占比
            if(StringUtils.isEmpty(villagePubSteelAssemblyNumProportion)){
                map.put("villagePubSteelAssemblyNumProportion","0.00%");
            }else {
                map.put("villagePubSteelAssemblyNumProportion",villagePubSteelAssemblyNumProportion);
            }
            //农村公共建筑轻钢（钢）装配式总面积
            map.put("villagePubSteelAssemblyArea",villagePubSteelAssemblyArea);
            //农村公共建筑轻钢（钢）装配式总面积占比
            if(StringUtils.isEmpty(villagePubSteelAssemblyAreaProportion)){
                map.put("villagePubSteelAssemblyAreaProportion","0.00%");
            }else {
                map.put("villagePubSteelAssemblyAreaProportion",villagePubSteelAssemblyAreaProportion);
            }
            //农村公共建筑混凝土装配式总数
            map.put("villagePubConcreteAssemblyNum",villagePubConcreteAssemblyNum);
            //农村住宅筑混凝土装配式总数占比
            if(StringUtils.isEmpty(villagePubConcreteAssemblyNumProportion)){
                map.put("villagePubConcreteAssemblyNumProportion","0.00%");
            }else {
                map.put("villagePubConcreteAssemblyNumProportion",villagePubConcreteAssemblyNumProportion);
            }
            //农村公共建筑混凝土装配式总面积
            map.put("villagePubConcreteAssemblyArea",villagePubConcreteAssemblyArea);
            //农村公共建筑轻混凝土装配式总面积占比
            if(StringUtils.isEmpty(villagePubConcreteAssemblyAreaProportion)){
                map.put("villagePubConcreteAssemblyAreaProportion","0.00%");
            }else {
                map.put("villagePubConcreteAssemblyAreaProportion",villagePubConcreteAssemblyAreaProportion);
            }
            //农村公共建筑砖木总数
            map.put("villagePubBrickWoodNum",villagePubBrickWoodNum);
            //农村公共建筑砖木总数占比
            if(StringUtils.isEmpty(villagePubBrickWoodNumProportion)){
                map.put("villagePubBrickWoodNumProportion","0.00%");
            }else {
                map.put("villagePubBrickWoodNumProportion",villagePubBrickWoodNumProportion);
            }
            //农村公共建筑砖木总面积
            map.put("villagePubBrickWoodArea",villagePubBrickWoodArea);
            //农村公共建筑砖木总面积占比
            if(StringUtils.isEmpty(villagePubBrickWoodAreaProportion)){
                map.put("villagePubBrickWoodAreaProportion","0.00%");
            }else {
                map.put("villagePubBrickWoodAreaProportion",villagePubBrickWoodAreaProportion);
            }
            //农村公共建筑土木总数
            map.put("villagePubCivilWoodNum",villagePubCivilWoodNum);
            //农村公共建筑土木总数占比
            if(StringUtils.isEmpty(villagePubCivilWoodNumProportion)){
                map.put("villagePubCivilWoodNumProportion","0.00%");
            }else {
                map.put("villagePubCivilWoodNumProportion",villagePubCivilWoodNumProportion);
            }
            //农村公共建筑土木总面积
            map.put("villagePubCivilWoodArea",villagePubCivilWoodArea);
            //农村公共建筑土木总面积占比
            if(StringUtils.isEmpty(villagePubCivilWoodAreaProportion)){
                map.put("villagePubCivilWoodAreaProportion","0.00%");
            }else {
                map.put("villagePubCivilWoodAreaProportion",villagePubCivilWoodAreaProportion);
            }
            //农村公共建筑石木总数
            map.put("villagePubStoneWoodNum",villagePubStoneWoodNum);
            //农村公共建筑石木总数占比
            if(StringUtils.isEmpty(villagePubStoneWoodNumProportion)){
                map.put("villagePubStoneWoodNumProportion","0.00%");
            }else {
                map.put("villagePubStoneWoodNumProportion",villagePubStoneWoodNumProportion);
            }
            //农村公共建筑石木总面积
            map.put("villagePubStoneWoodArea",villagePubStoneWoodArea);
            //农村公共建筑石木总面积占比
            if(StringUtils.isEmpty(villagePubStoneWoodAreaProportion)){
                map.put("villagePubStoneWoodAreaProportion","0.00%");
            }else {
                map.put("villagePubStoneWoodAreaProportion",villagePubStoneWoodAreaProportion);
            }
            //农村公共建筑木结构总数
            map.put("villagePubWoodStructureNum",villagePubWoodStructureNum);
            //农村公共建筑木结构总数占比
            if(StringUtils.isEmpty(villagePubWoodStructureNumProportion)){
                map.put("villagePubWoodStructureNumProportion","0.00%");
            }else {
                map.put("villagePubWoodStructureNumProportion",villagePubWoodStructureNumProportion);
            }
            //农村公共建筑木结构总面积
            map.put("villagePubWoodStructureArea",villagePubWoodStructureArea);
            //农村公共建筑木结构总面积占比
            if(StringUtils.isEmpty(villagePubWoodStructureAreaProportion)){
                map.put("villagePubWoodStructureAreaProportion","0.00%");
            }else {
                map.put("villagePubWoodStructureAreaProportion",villagePubWoodStructureAreaProportion);
            }
            //农村公共建筑窑洞总数
            map.put("villagePubCaveDwellingNum",villagePubCaveDwellingNum);
            //农村公共建筑窑洞总数占比
            if(StringUtils.isEmpty(villagePubCaveDwellingNumProportion)){
                map.put("villagePubCaveDwellingNumProportion","0.00%");
            }else {
                map.put("villagePubCaveDwellingNumProportion",villagePubCaveDwellingNumProportion);
            }
            //农村公共建筑窑洞总面积
            map.put("villagePubCaveDwellingArea",villagePubCaveDwellingArea);
            //农村公共建筑窑洞总面积占比
            if(StringUtils.isEmpty(villagePubCaveDwellingAreaProportion)){
                map.put("villagePubCaveDwellingAreaProportion","0.00%");
            }else {
                map.put("villagePubCaveDwellingAreaProportion",villagePubCaveDwellingAreaProportion);
            }
            //农村公共建筑混杂结构（砖/砌块/土/石）总数
            map.put("villagePubMixedStructureNum",villagePubMixedStructureNum);
            //农村公共建筑混杂结构（砖/砌块/土/石）总数占比
            if(StringUtils.isEmpty(villagePubMixedStructureNumProportion)){
                map.put("villagePubMixedStructureNumProportion","0.00%");
            }else {
                map.put("villagePubMixedStructureNumProportion",villagePubMixedStructureNumProportion);
            }
            //农村公共建筑混杂结构（砖/砌块/土/石）总面积
            map.put("villagePubMixedStructureArea",villagePubMixedStructureArea);
            //农村公共建筑混杂结构（砖/砌块/土/石）总面积占比
            if(StringUtils.isEmpty(villagePubMixedStructureAreaProportion)){
                map.put("villagePubMixedStructureAreaProportion","0.00%");
            }else {
                map.put("villagePubMixedStructureAreaProportion",villagePubMixedStructureAreaProportion);
            }
            //农村公共建筑其它总数
            map.put("villagePubOtherNum",villagePubOtherNum);
            //农村公共建筑其它总数占比
            if(StringUtils.isEmpty(villagePubOtherNumProportion)){
                map.put("villagePubOtherNumProportion","0.00%");
            }else {
                map.put("villagePubOtherNumProportion",villagePubOtherNumProportion);
            }
            //农村公共建筑其它总面积
            map.put("villagePubOtherArea",villagePubOtherArea);
            //农村公共建筑其它总面积占比
            if(StringUtils.isEmpty(villagePubOtherAreaProportion)){
                map.put("villagePubOtherAreaProportion","0.00%");
            }else {
                map.put("villagePubOtherAreaProportion",villagePubOtherAreaProportion);
            }
            try {
                result = fromList.size();
                //System.out.println(map.toString());
                WordUtil.exportMillCertificateWord(request, response, map, "数据采集报告（普查）", "20200512-数据采集报告（普查）.ftl");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public Map<String, Object> buildingNumData(AnalysisQueryVo analysisQueryVo) {
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 城镇住宅、城镇非住宅、农村住房、农村公共建筑 数量
        long cityTaskCount = cityTaskFormService.count(analysisQueryVo);
        long noCityTaskCount = noCityTaskFromService.count(analysisQueryVo);
        long villageHouseCount = villageHouseFormService.count(analysisQueryVo);
        long villagePubHouseCount = villagePubHouseFormService.count(analysisQueryVo);
        // X轴数据
        ArrayList<String> x = new ArrayList<>();
        x.add("城镇住宅");
        x.add("城镇非住宅");
        x.add("农村住房");
        x.add("农村公共建筑数量");
        // Y轴数据
        ArrayList<Long> y = new ArrayList<>();
        y.add(cityTaskCount);
        y.add(noCityTaskCount);
        y.add(villageHouseCount);
        y.add(villagePubHouseCount);
        // 返回结果Map
        HashMap<String, Object> map = new HashMap<>();
        map.put("x", x);
        map.put("y", y);
        return map;
    }

    @Override
    public Map<String, Object> buildingAreaData(AnalysisQueryVo analysisQueryVo) {
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 城镇住宅、城镇非住宅、农村住房、农村公共建筑 面积
        int cityTaskCount = cityTaskFormService.areaCount(analysisQueryVo);
        int noCityTaskCount = noCityTaskFromService.areaCount(analysisQueryVo);
        int villageHouseCount = villageHouseFormService.areaCount(analysisQueryVo);
        int villagePubHouseCount = villagePubHouseFormService.areaCount(analysisQueryVo);
        // X轴数据
        ArrayList<String> x = new ArrayList<>();
        x.add("城镇住宅");
        x.add("城镇非住宅");
        x.add("农村住房");
        x.add("农村公共建筑数量");
        // Y轴数据
        ArrayList<Integer> y = new ArrayList<>();
        y.add(cityTaskCount);
        y.add(noCityTaskCount);
        y.add(villageHouseCount);
        y.add(villagePubHouseCount);
        // 返回结果Map
        HashMap<String, Object> map = new HashMap<>();
        map.put("x", x);
        map.put("y", y);
        return map;
    }

    @Override
    public List<Map> buildingCityNumDataByStructureType(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砖混", "底层混凝土柱-上部砖混", "钢筋混凝土", "砖木", "钢结构", "木结构", "其它"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String structureType : array) {
            // 结构类型查询参数变化
            analysisQueryVo.setStructureType(structureType);
            Long count = 0L;
            // 城镇住宅、城镇非住宅 数量
            long cityTaskCount = cityTaskFormService.count(analysisQueryVo);
            long noCityTaskCount = noCityTaskFromService.count(analysisQueryVo);
            count = cityTaskCount + noCityTaskCount;
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingVillageNumDataByStructureType(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砖（砌块）混", "低层框架", "轻钢（钢）装配式", "混凝土装配式", "砖木","土木", "石木","木结构","窑洞","混杂结构(砖/砌块/土/石)","其它"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String structureType : array) {
            // 结构类型查询参数变化
            analysisQueryVo.setStructureType(structureType);
            Long count = 0L;
            // 农村住房、农村公共建筑 数量
            long villageHouseCount = villageHouseFormService.count(analysisQueryVo);
            long villagePubHouseCount = villagePubHouseFormService.count(analysisQueryVo);
            count = villageHouseCount + villagePubHouseCount;
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            result.add(map);

        }
        return result;
    }

    @Override
    public List<Map> buildingCityAreaDataByStructureType(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砖混", "底层混凝土柱-上部砖混", "钢筋混凝土", "砖木", "钢结构", "木结构", "其它"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String structureTyp : array) {
            // 结构类型查询参数变化
            analysisQueryVo.setStructureType(structureTyp);
            Long count = 0L;
            // 城镇住宅、城镇非住宅 数量
            long cityTaskCount = cityTaskFormService.areaCount(analysisQueryVo);
            long noCityTaskCount = noCityTaskFromService.areaCount(analysisQueryVo);
            count = cityTaskCount + noCityTaskCount;
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureTyp);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingVillageAreaDataByStructureType(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砖（砌块）混", "低层框架", "轻钢（钢）装配式", "混凝土装配式", "砖木","土木", "石木","木结构","窑洞","混杂结构(砖/砌块/土/石)","其它"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String structureTyp : array) {
            // 结构类型查询参数变化
            analysisQueryVo.setStructureType(structureTyp);
            Long count = 0L;
            // 农村住房、农村公共建筑 数量
            long villageHouseCount = villageHouseFormService.areaCount(analysisQueryVo);
            long villagePubHouseCount = villagePubHouseFormService.areaCount(analysisQueryVo);
            count = villageHouseCount + villagePubHouseCount;
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureTyp);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingNumCityByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前","70s","80s","90s","00s","10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = cityTaskFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaCityByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = cityTaskFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumNoCityByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = noCityTaskFromService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaNoCityByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = noCityTaskFromService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 结构类型查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillagePubByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = villagePubHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillagePubByBuildingTime(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"70s以前", "70s", "80s", "90s", "00s", "10s"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 年代查询参数变化
            analysisQueryVo.setBuildingTime(structureType);
            long count = villagePubHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumCityByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = cityTaskFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaCityByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = cityTaskFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumNoCityByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = noCityTaskFromService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaNoCityByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = noCityTaskFromService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillagePubByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 震设防烈度查询参数变化
            analysisQueryVo.setNowFortificationIntensity(structureType);
            long count = villagePubHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillagePubByFortificationIntensity(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未设防", "6度", "7度", "8度", "9度", "10度"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = villagePubHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByHouseMeasures(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"基本完备", "部分具备", "完全没有"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防烈度查询参数变化
            analysisQueryVo.setHouseMeasures(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByHouseMeasures(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"基本完备", "部分具备", "完全没有"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防烈度查询参数变化
            analysisQueryVo.setHouseMeasures(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByOnceAffected(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"地震", "洪水", "台风","雪灾","火灾","其它"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 曾受灾情况查询参数变化
            analysisQueryVo.setOnceAffected(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByOnceAffected(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"地震","洪水", "台风","雪灾","火灾","其它"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 曾受灾情况查询参数变化
            analysisQueryVo.setOnceAffected(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumCityByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = cityTaskFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaCityByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = cityTaskFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumCityByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = cityTaskFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaCityByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = cityTaskFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumNoCityByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = noCityTaskFromService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaNoCityByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = noCityTaskFromService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumNoCityByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = noCityTaskFromService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaNoCityByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = noCityTaskFromService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"满足抗震设防要求且质量较好", "不满足抗震设防要求且质量很差", "需要进一步鉴定"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"满足抗震设防要求且质量较好", "不满足抗震设防要求且质量很差", "需要进一步鉴定"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillageByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = villageHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillageByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = villageHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillagePubByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = villagePubHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillagePubByResult(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"未抗震设防", "抗震设防能力不足", "基本符合抗震设防要求"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 抗震设防情况查询参数变化
            analysisQueryVo.setResult(structureType);
            long count = villagePubHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }

    @Override
    public List<Map> buildingNumVillagePubByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        // 建筑数量
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = villagePubHouseFormService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> buildingAreaVillagePubByBuildingIsDamage(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有", "无"};
        //查询审核通过的数据
        analysisQueryVo.setSpType(Constant.SP_YES);
        //建筑面积
        ArrayList<Map> resultArea = new ArrayList<>();
        for (String structureType:array) {
            // 安全隐患查询参数变化
            analysisQueryVo.setIsDamage(structureType);
            long count = villagePubHouseFormService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", structureType);
            resultArea.add(map);
        }
        return resultArea;
    }


}
